Cython: simulate_particle

Yellow lines hint at Python interaction.
Click on a line that starts with a "+" to see the C code that Cython generated for it.

+001: # cython: infer_types=True, wraparound=False, nonecheck=False, boundscheck=False, cdivision=True, language_level=3, profile=False, autogen_pxd=True

  __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_t_7, __pyx_kp_u_simulate_particle_field_based_on_2, __pyx_kp_u_Simulate_a_particle_field_based) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

 002:

 003: from ..utils.random cimport _random

 004: from ..transform.interpolation_catmull_rom cimport _interpolate

 005: from ..generate.noise_add_gaussians cimport _render_erf_gaussian

 006:

 007: from libc.math cimport sqrt, fabs

 008:

+009: import numpy as np

  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

 010: cimport numpy as np

 011:

 012: from cython.parallel import prange

+013: from tqdm import tqdm

  __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_n_s_tqdm);
  __Pyx_GIVEREF(__pyx_n_s_tqdm);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_tqdm)) __PYX_ERR(0, 13, __pyx_L1_error);
  __pyx_t_4 = __Pyx_Import(__pyx_n_s_tqdm, __pyx_t_7, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_tqdm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_tqdm, __pyx_t_7) < 0) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 014:

+015: def simulate_particle_field_based_on_2D_PDF(image_pdf,

static PyObject *__pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_10__defaults__(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__defaults__", 0);
  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_min_particles);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_min_particles);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_min_particles)) __PYX_ERR(0, 15, __pyx_L1_error);
  __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_max_particles);
  __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_max_particles);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_max_particles)) __PYX_ERR(0, 15, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error);
  __Pyx_INCREF(((PyObject *)__pyx_int_1));
  __Pyx_GIVEREF(((PyObject *)__pyx_int_1));
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, ((PyObject *)__pyx_int_1))) __PYX_ERR(0, 15, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, Py_None)) __PYX_ERR(0, 15, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_1simulate_particle_field_based_on_2D_PDF(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_simulate_particle_field_based_on_2D_PDF, "\n    Simulate a particle field based on a 2D probability density function (PDF)\n    :param image_pdf: 2D array of floats, the PDF\n    :param min_particles: int, the minimum number of particles to simulate\n    :param max_particles: int, the maximum number of particles to simulate\n    :param min_distance: float, ensure that paricle distances are above minimum distance given\n    :param mean_distance_threshold: float, the mean distance between closest particles, if the mean distance is below this threshold, the simulation will stop\n    :param normalize: bint, whether or not the image requires normalization\n    :param max_tries: int, the maximum number of tries to place particles before giving up\n    :return: (2D array of floats, mean closest distance), for the first tupple element the shape is (n_particles, 2) where the last dimension is the x and y coordinates of the simulated particle\n\n    The code does the following:\n    1. It samples the image PDF and places a particle at a point with a probability that is proportional to the PDF at that point.\n    2. It places the particles such that no two particles are closer than `min_distance` pixels.\n    3. It stops placing particles once the mean distance between all particles is less than `mean_distance_threshold` pixels.\n\n    Example:\n    >>> import numpy as np\n    >>> image_pdf = np.random.random((100, 200)).astype(np.float32)\n    >>> particles = simulate_particle_field_based_on_2D_PDF(image_pdf, min_particles=100, mean_distance_threshold=0.1)\n    ");
static PyMethodDef __pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_1simulate_particle_field_based_on_2D_PDF = {"simulate_particle_field_based_on_2D_PDF", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_1simulate_particle_field_based_on_2D_PDF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_simulate_particle_field_based_on_2D_PDF};
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_1simulate_particle_field_based_on_2D_PDF(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_image_pdf = 0;
  PyObject *__pyx_v_min_particles = 0;
  PyObject *__pyx_v_max_particles = 0;
  double __pyx_v_min_distance;
  double __pyx_v_mean_distance_threshold;
  PyObject *__pyx_v_normalize = 0;
  int __pyx_v_max_tries;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("simulate_particle_field_based_on_2D_PDF (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_MACROS
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args);
  if (unlikely((__pyx_nargs < 0))) __PYX_ERR(0, 15, __pyx_L3_error)
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_image_pdf,&__pyx_n_s_min_particles,&__pyx_n_s_max_particles,&__pyx_n_s_min_distance,&__pyx_n_s_mean_distance_threshold,&__pyx_n_s_normalize,&__pyx_n_s_max_tries,0};
  PyObject* values[7] = {0,0,0,0,0,0,0};
    __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self);
    values[1] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_min_particles);
    values[2] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_max_particles);
    values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_1)));
    if (__pyx_kwds) {
      Py_ssize_t kw_args;
      switch (__pyx_nargs) {
        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
      switch (__pyx_nargs) {
        case  0:
        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_image_pdf)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_min_particles);
          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_max_particles);
          if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_min_distance);
          if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mean_distance_threshold);
          if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_normalize);
          if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_max_tries);
          if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 15, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        const Py_ssize_t kwd_pos_args = __pyx_nargs;
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "simulate_particle_field_based_on_2D_PDF") < 0)) __PYX_ERR(0, 15, __pyx_L3_error)
      }
    } else {
      switch (__pyx_nargs) {
        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_image_pdf = values[0];
    __pyx_v_min_particles = ((PyObject*)values[1]);
    __pyx_v_max_particles = ((PyObject*)values[2]);
    if (values[3]) {
      __pyx_v_min_distance = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_min_distance == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 17, __pyx_L3_error)
    } else {
      __pyx_v_min_distance = ((double)((double)0.1));
    }
    if (values[4]) {
      __pyx_v_mean_distance_threshold = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_mean_distance_threshold == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 17, __pyx_L3_error)
    } else {
      __pyx_v_mean_distance_threshold = ((double)((double)0.0));
    }
    __pyx_v_normalize = values[5];
    if (values[6]) {
      __pyx_v_max_tries = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_max_tries == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 17, __pyx_L3_error)
    } else {
      __pyx_v_max_tries = ((int)((int)3));
    }
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("simulate_particle_field_based_on_2D_PDF", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 15, __pyx_L3_error)
  goto __pyx_L3_error;
  __pyx_L3_error:;
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.simulate_particle_field_based_on_2D_PDF", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_min_particles), (&PyInt_Type), 0, "min_particles", 1))) __PYX_ERR(0, 16, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_max_particles), (&PyInt_Type), 0, "max_particles", 1))) __PYX_ERR(0, 16, __pyx_L1_error)
  __pyx_r = __pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_simulate_particle_field_based_on_2D_PDF(__pyx_self, __pyx_v_image_pdf, __pyx_v_min_particles, __pyx_v_max_particles, __pyx_v_min_distance, __pyx_v_mean_distance_threshold, __pyx_v_normalize, __pyx_v_max_tries);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_simulate_particle_field_based_on_2D_PDF(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_image_pdf, PyObject *__pyx_v_min_particles, PyObject *__pyx_v_max_particles, double __pyx_v_min_distance, double __pyx_v_mean_distance_threshold, PyObject *__pyx_v_normalize, int __pyx_v_max_tries) {
  PyObject *__pyx_v_valid_indices = NULL;
  PyObject *__pyx_v_n_valid_indices = NULL;
  PyObject *__pyx_v_selected_indices = NULL;
  PyObject *__pyx_v_xp = NULL;
  PyObject *__pyx_v_yp = NULL;
  __Pyx_memviewslice __pyx_v__image_pdf = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v__max_particles;
  int __pyx_v__min_particles;
  float __pyx_v__min_distance;
  int __pyx_v__max_tries;
  float __pyx_v__mean_distance_threshold;
  __Pyx_memviewslice __pyx_v__xp = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v__yp = { 0, 0, { 0 }, { 0 }, { 0 } };
  CYTHON_UNUSED PyArrayObject *__pyx_v_particles_not_set = 0;
  PyArrayObject *__pyx_v_particles_set = 0;
  int __pyx_v_n_particles;
  int __pyx_v_previous_n_particles;
  int __pyx_v_p;
  int __pyx_v_tries;
  float __pyx_v_closest_distance;
  float __pyx_v_closest_distance_sum;
  float __pyx_v_mean_closest_distance;
  PyObject *__pyx_v_progress_bar = NULL;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_particles_not_set;
  __Pyx_Buffer __pyx_pybuffer_particles_not_set;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_particles_set;
  __Pyx_Buffer __pyx_pybuffer_particles_set;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("simulate_particle_field_based_on_2D_PDF", 0);
  __Pyx_INCREF(__pyx_v_image_pdf);
  __pyx_pybuffer_particles_not_set.pybuffer.buf = NULL;
  __pyx_pybuffer_particles_not_set.refcount = 0;
  __pyx_pybuffernd_particles_not_set.data = NULL;
  __pyx_pybuffernd_particles_not_set.rcbuffer = &__pyx_pybuffer_particles_not_set;
  __pyx_pybuffer_particles_set.pybuffer.buf = NULL;
  __pyx_pybuffer_particles_set.refcount = 0;
  __pyx_pybuffernd_particles_set.data = NULL;
  __pyx_pybuffernd_particles_set.rcbuffer = &__pyx_pybuffer_particles_set;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.simulate_particle_field_based_on_2D_PDF", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_valid_indices);
  __Pyx_XDECREF(__pyx_v_n_valid_indices);
  __Pyx_XDECREF(__pyx_v_selected_indices);
  __Pyx_XDECREF(__pyx_v_xp);
  __Pyx_XDECREF(__pyx_v_yp);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v__image_pdf, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v__xp, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v__yp, 1);
  __Pyx_XDECREF((PyObject *)__pyx_v_particles_not_set);
  __Pyx_XDECREF((PyObject *)__pyx_v_particles_set);
  __Pyx_XDECREF(__pyx_v_progress_bar);
  __Pyx_XDECREF(__pyx_v_image_pdf);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__26 = PyTuple_Pack(30, __pyx_n_s_image_pdf, __pyx_n_s_min_particles, __pyx_n_s_max_particles, __pyx_n_s_min_distance, __pyx_n_s_mean_distance_threshold, __pyx_n_s_normalize, __pyx_n_s_max_tries, __pyx_n_s_valid_indices, __pyx_n_s_n_valid_indices, __pyx_n_s_selected_indices, __pyx_n_s_xp, __pyx_n_s_yp, __pyx_n_s_image_pdf_2, __pyx_n_s_max_particles_2, __pyx_n_s_min_particles_2, __pyx_n_s_min_distance_2, __pyx_n_s_max_tries_2, __pyx_n_s_mean_distance_threshold_2, __pyx_n_s_xp_2, __pyx_n_s_yp_2, __pyx_n_s_particles_not_set, __pyx_n_s_particles_set, __pyx_n_s_n_particles, __pyx_n_s_previous_n_particles, __pyx_n_s_p, __pyx_n_s_tries, __pyx_n_s_closest_distance, __pyx_n_s_closest_distance_sum, __pyx_n_s_mean_closest_distance, __pyx_n_s_progress_bar); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__26);
  __Pyx_GIVEREF(__pyx_tuple__26);
/* … */
  __pyx_t_4 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_min_particles, __pyx_n_s_int) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_max_particles, __pyx_n_s_int) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_min_distance, __pyx_n_s_float) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_mean_distance_threshold, __pyx_n_s_float) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_normalize, __pyx_n_s_bint) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_1simulate_particle_field_based_on_2D_PDF, 0, __pyx_n_s_simulate_particle_field_based_on, NULL, __pyx_n_s_nanopyx_core_generate_simulate_p, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (!__Pyx_CyFunction_InitDefaults(__pyx_t_7, sizeof(__pyx_defaults), 2)) __PYX_ERR(0, 15, __pyx_L1_error)
  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 30, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_nanopyx_core_generate_simula, __pyx_n_s_simulate_particle_field_based_on, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 15, __pyx_L1_error)

+016:                                             min_particles: int = 10, max_particles: int = 1000,

  if (!(likely(__Pyx_Py3Int_CheckExact(__pyx_int_10)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_int_10))) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_INCREF(__pyx_int_10);
  __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_7)->__pyx_arg_min_particles = ((PyObject*)__pyx_int_10);
  __Pyx_GIVEREF(__pyx_int_10);
  if (!(likely(__Pyx_Py3Int_CheckExact(__pyx_int_1000)) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_int_1000))) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_INCREF(__pyx_int_1000);
  __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_7)->__pyx_arg_max_particles = ((PyObject*)__pyx_int_1000);
  __Pyx_GIVEREF(__pyx_int_1000);
  __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_7, __pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_10__defaults__);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_7, __pyx_t_4);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_simulate_particle_field_based_on, __pyx_t_7) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+017:                                             min_distance: float = 0.1, mean_distance_threshold: float = 0, normalize: bint = 1, int max_tries = 3):

  __pyx_t_1 = PyFloat_FromDouble(((double)0.1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyInt_From_int(((int)3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);

 018:     """

 019:     Simulate a particle field based on a 2D probability density function (PDF)

 020:     :param image_pdf: 2D array of floats, the PDF

 021:     :param min_particles: int, the minimum number of particles to simulate

 022:     :param max_particles: int, the maximum number of particles to simulate

 023:     :param min_distance: float, ensure that paricle distances are above minimum distance given

 024:     :param mean_distance_threshold: float, the mean distance between closest particles, if the mean distance is below this threshold, the simulation will stop

 025:     :param normalize: bint, whether or not the image requires normalization

 026:     :param max_tries: int, the maximum number of tries to place particles before giving up

 027:     :return: (2D array of floats, mean closest distance), for the first tupple element the shape is (n_particles, 2) where the last dimension is the x and y coordinates of the simulated particle

 028:

 029:     The code does the following:

 030:     1. It samples the image PDF and places a particle at a point with a probability that is proportional to the PDF at that point.

 031:     2. It places the particles such that no two particles are closer than `min_distance` pixels.

 032:     3. It stops placing particles once the mean distance between all particles is less than `mean_distance_threshold` pixels.

 033:

 034:     Example:

 035:     >>> import numpy as np

 036:     >>> image_pdf = np.random.random((100, 200)).astype(np.float32)

 037:     >>> particles = simulate_particle_field_based_on_2D_PDF(image_pdf, min_particles=100, mean_distance_threshold=0.1)

 038:     """

+039:     assert image_pdf.dtype == np.float32 and image_pdf.ndim == 2

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_5) {
    } else {
      __pyx_t_1 = __pyx_t_5;
      goto __pyx_L3_bool_binop_done;
    }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = (__Pyx_PyInt_BoolEqObjC(__pyx_t_3, __pyx_int_2, 2, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 39, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_1 = __pyx_t_5;
    __pyx_L3_bool_binop_done:;
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 39, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 39, __pyx_L1_error)
  #endif

 040:

+041:     if normalize:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_normalize); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 41, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+042:         if image_pdf.max() == image_pdf.min(): # if the image_pdf has the same intensity all across the image..

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = NULL;
    __pyx_t_6 = 0;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_2)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
        __pyx_t_6 = 1;
      }
    }
    #endif
    {
      PyObject *__pyx_callargs[1] = {__pyx_t_2, };
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_min); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = NULL;
    __pyx_t_6 = 0;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_7)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_6 = 1;
      }
    }
    #endif
    {
      PyObject *__pyx_callargs[1] = {__pyx_t_7, };
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 42, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_1) {
/* … */
      goto __pyx_L6;
    }

+043:             image_pdf = np.full_like(image_pdf, 0.5)

      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_full_like); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 43, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = NULL;
      __pyx_t_6 = 0;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
        if (likely(__pyx_t_4)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_3, function);
          __pyx_t_6 = 1;
        }
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_image_pdf, __pyx_float_0_5};
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      }
      __Pyx_DECREF_SET(__pyx_v_image_pdf, __pyx_t_2);
      __pyx_t_2 = 0;

 044:         else:

+045:             image_pdf = (image_pdf - image_pdf.min()) / (image_pdf.max() - image_pdf.min())

    /*else*/ {
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = NULL;
      __pyx_t_6 = 0;
      #if CYTHON_UNPACK_METHODS
      if (likely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
        if (likely(__pyx_t_4)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_3, function);
          __pyx_t_6 = 1;
        }
      }
      #endif
      {
        PyObject *__pyx_callargs[1] = {__pyx_t_4, };
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      }
      __pyx_t_3 = PyNumber_Subtract(__pyx_v_image_pdf, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_7 = NULL;
      __pyx_t_6 = 0;
      #if CYTHON_UNPACK_METHODS
      if (likely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
        if (likely(__pyx_t_7)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_7);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_4, function);
          __pyx_t_6 = 1;
        }
      }
      #endif
      {
        PyObject *__pyx_callargs[1] = {__pyx_t_7, };
        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      }
      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_image_pdf, __pyx_n_s_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 45, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_8 = NULL;
      __pyx_t_6 = 0;
      #if CYTHON_UNPACK_METHODS
      if (likely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
        if (likely(__pyx_t_8)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
          __Pyx_INCREF(__pyx_t_8);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_7, function);
          __pyx_t_6 = 1;
        }
      }
      #endif
      {
        PyObject *__pyx_callargs[1] = {__pyx_t_8, };
        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      }
      __pyx_t_7 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 45, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF_SET(__pyx_v_image_pdf, __pyx_t_4);
      __pyx_t_4 = 0;
    }
    __pyx_L6:;

 046:         # image_pdf = image_pdf / np.linalg.norm(image_pdf, axis=1, keepdims=True)

 047:

+048:     assert np.max(image_pdf) <= 1.0 and np.min(image_pdf) >= 0.0

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = NULL;
    __pyx_t_6 = 0;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
      if (likely(__pyx_t_7)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_3, function);
        __pyx_t_6 = 1;
      }
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_image_pdf};
      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_float_1_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_5) {
    } else {
      __pyx_t_1 = __pyx_t_5;
      goto __pyx_L7_bool_binop_done;
    }
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = NULL;
    __pyx_t_6 = 0;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_7))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_7, function);
        __pyx_t_6 = 1;
      }
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_image_pdf};
      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 48, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_1 = __pyx_t_5;
    __pyx_L7_bool_binop_done:;
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 48, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 48, __pyx_L1_error)
  #endif

 049:

 050:     # Check for values where the PDF is non-zero (and only place particles at those locations)

+051:     valid_indices = np.nonzero(image_pdf > 0)

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_nonzero); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyObject_RichCompare(__pyx_v_image_pdf, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)
  __pyx_t_2 = NULL;
  __pyx_t_6 = 0;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_2)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
      __pyx_t_6 = 1;
    }
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  }
  __pyx_v_valid_indices = __pyx_t_7;
  __pyx_t_7 = 0;

+052:     valid_indices = np.transpose(valid_indices)

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_transpose); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = NULL;
  __pyx_t_6 = 0;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
      __pyx_t_6 = 1;
    }
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_valid_indices};
    __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 52, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  }
  __Pyx_DECREF_SET(__pyx_v_valid_indices, __pyx_t_7);
  __pyx_t_7 = 0;

+053:     n_valid_indices = valid_indices.shape[0]

  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_valid_indices, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_v_n_valid_indices = __pyx_t_3;
  __pyx_t_3 = 0;

 054:

+055:     if n_valid_indices == 0:

  __pyx_t_1 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_n_valid_indices, __pyx_int_0, 0, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 55, __pyx_L1_error)
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+056:         raise ValueError("No valid locations found in the image PDF")

    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 56, __pyx_L1_error)
/* … */
  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_No_valid_locations_found_in_the); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 56, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

 057:

+058:     np.random.shuffle(valid_indices)

  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_shuffle); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = NULL;
  __pyx_t_6 = 0;
  #if CYTHON_UNPACK_METHODS
  if (likely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_7, function);
      __pyx_t_6 = 1;
    }
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_valid_indices};
    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+059:     selected_indices = valid_indices[:int(max_particles),:]

  __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_max_particles); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = PySlice_New(Py_None, __pyx_t_3, Py_None); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error);
  __Pyx_INCREF(__pyx_slice__5);
  __Pyx_GIVEREF(__pyx_slice__5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_slice__5)) __PYX_ERR(0, 59, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_valid_indices, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_selected_indices = __pyx_t_7;
  __pyx_t_7 = 0;

 060:

+061:     xp = selected_indices[:, 1]

  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_selected_indices, __pyx_tuple__12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_v_xp = __pyx_t_7;
  __pyx_t_7 = 0;
/* … */
  __pyx_tuple__12 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_1); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);

+062:     yp = selected_indices[:, 0]

  __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_selected_indices, __pyx_tuple__13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_v_yp = __pyx_t_7;
  __pyx_t_7 = 0;
/* … */
  __pyx_tuple__13 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_0); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__13);
  __Pyx_GIVEREF(__pyx_tuple__13);

 063:

+064:     cdef float[:,:] _image_pdf = image_pdf

  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_image_pdf, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 64, __pyx_L1_error)
  __pyx_v__image_pdf = __pyx_t_9;
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;

 065:

+066:     cdef int _max_particles = max_particles

  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_max_particles); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 66, __pyx_L1_error)
  __pyx_v__max_particles = __pyx_t_6;

+067:     cdef int _min_particles = min_particles

  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_min_particles); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L1_error)
  __pyx_v__min_particles = __pyx_t_6;

+068:     cdef float _min_distance = min_distance

  __pyx_v__min_distance = __pyx_v_min_distance;

+069:     cdef int _max_tries = max_tries

  __pyx_v__max_tries = __pyx_v_max_tries;

+070:     cdef float _mean_distance_threshold = mean_distance_threshold

  __pyx_v__mean_distance_threshold = __pyx_v_mean_distance_threshold;

 071:

+072:     xp = np.full(_max_particles, -999999, dtype=np.float32)

  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_full); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v__max_particles); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_7);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7)) __PYX_ERR(0, 72, __pyx_L1_error);
  __Pyx_INCREF(__pyx_int_neg_999999);
  __Pyx_GIVEREF(__pyx_int_neg_999999);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_neg_999999)) __PYX_ERR(0, 72, __pyx_L1_error);
  __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float32); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF_SET(__pyx_v_xp, __pyx_t_8);
  __pyx_t_8 = 0;

+073:     yp = np.full(_max_particles, -999999, dtype=np.float32)

  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_full); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v__max_particles); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8)) __PYX_ERR(0, 73, __pyx_L1_error);
  __Pyx_INCREF(__pyx_int_neg_999999);
  __Pyx_GIVEREF(__pyx_int_neg_999999);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_neg_999999)) __PYX_ERR(0, 73, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF_SET(__pyx_v_yp, __pyx_t_2);
  __pyx_t_2 = 0;

+074:     cdef float[:] _xp = xp  # xp exists in python land, _xp in c land as memoryview

  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_xp, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 74, __pyx_L1_error)
  __pyx_v__xp = __pyx_t_10;
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;

+075:     cdef float[:] _yp = yp  # same as above

  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_yp, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 75, __pyx_L1_error)
  __pyx_v__yp = __pyx_t_10;
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;

 076:

 077:     cdef np.ndarray[np.int32_t, ndim=1] particles_not_set, particles_set

 078:

+079:     cdef int n_particles = 0

  __pyx_v_n_particles = 0;

+080:     cdef int previous_n_particles = 0

  __pyx_v_previous_n_particles = 0;

 081:     cdef int p

+082:     cdef int tries = 0

  __pyx_v_tries = 0;

 083:     cdef float closest_distance, closest_distance_sum, mean_closest_distance

 084:

 085:     # start by creating the minimal pool of particles

+086:     with tqdm(total=max_particles, desc="Generating particles", unit="particles") as progress_bar:

  /*with:*/ {
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_tqdm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_8 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 86, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_total, __pyx_v_max_particles) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
    if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_desc, __pyx_kp_u_Generating_particles) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
    if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_unit, __pyx_n_u_particles) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 86, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_11 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 86, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L10_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_7 = NULL;
    __pyx_t_6 = 0;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_7)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_6 = 1;
      }
    }
    #endif
    {
      PyObject *__pyx_callargs[1] = {__pyx_t_7, };
      __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 86, __pyx_L10_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __pyx_t_2 = __pyx_t_8;
    __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    /*try:*/ {
      {
        /*try:*/ {
          __pyx_v_progress_bar = __pyx_t_2;
          __pyx_t_2 = 0;
/* … */
        }
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
        goto __pyx_L19_try_end;
        __pyx_L14_error:;
        __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1);
        __pyx_t_10.memview = NULL; __pyx_t_10.data = NULL;
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1);
        __pyx_t_9.memview = NULL; __pyx_t_9.data = NULL;
        /*except:*/ {
          __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.simulate_particle_field_based_on_2D_PDF", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_8) < 0) __PYX_ERR(0, 86, __pyx_L16_except_error)
          __Pyx_XGOTREF(__pyx_t_2);
          __Pyx_XGOTREF(__pyx_t_4);
          __Pyx_XGOTREF(__pyx_t_8);
          __pyx_t_7 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 86, __pyx_L16_except_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_7, NULL);
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 86, __pyx_L16_except_error)
          __Pyx_GOTREF(__pyx_t_16);
          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_16);
          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
          if (__pyx_t_1 < 0) __PYX_ERR(0, 86, __pyx_L16_except_error)
          __pyx_t_5 = (!__pyx_t_1);
          if (unlikely(__pyx_t_5)) {
            __Pyx_GIVEREF(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_4);
            __Pyx_XGIVEREF(__pyx_t_8);
            __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_4, __pyx_t_8);
            __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_8 = 0; 
            __PYX_ERR(0, 86, __pyx_L16_except_error)
          }
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          goto __pyx_L15_exception_handled;
        }
        __pyx_L16_except_error:;
        __Pyx_XGIVEREF(__pyx_t_12);
        __Pyx_XGIVEREF(__pyx_t_13);
        __Pyx_XGIVEREF(__pyx_t_14);
        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
        goto __pyx_L1_error;
        __pyx_L15_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_12);
        __Pyx_XGIVEREF(__pyx_t_13);
        __Pyx_XGIVEREF(__pyx_t_14);
        __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
        __pyx_L19_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_11) {
          __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__14, NULL);
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 86, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_14);
          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        }
        goto __pyx_L13;
      }
      __pyx_L13:;
    }
    goto __pyx_L57;
    __pyx_L10_error:;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    goto __pyx_L1_error;
    __pyx_L57:;
  }
/* … */
  __pyx_tuple__14 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__14);
  __Pyx_GIVEREF(__pyx_tuple__14);

+087:         while 1:

          while (1) {

+088:             particles_not_set = np.nonzero(xp < 0)[0].astype(np.int32)  # get the index for the parciles not yet set

            __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 88, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_nonzero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 88, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_7);
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_8 = PyObject_RichCompare(__pyx_v_xp, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 88, __pyx_L14_error)
            __pyx_t_3 = NULL;
            __pyx_t_6 = 0;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_7))) {
              __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
              if (likely(__pyx_t_3)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
                __Pyx_INCREF(__pyx_t_3);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_7, function);
                __pyx_t_6 = 1;
              }
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8};
              __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L14_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            }
            __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 88, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_7);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 88, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_7);
            __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 88, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __pyx_t_7 = NULL;
            __pyx_t_6 = 0;
            #if CYTHON_UNPACK_METHODS
            if (likely(PyMethod_Check(__pyx_t_4))) {
              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
              if (likely(__pyx_t_7)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
                __Pyx_INCREF(__pyx_t_7);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_4, function);
                __pyx_t_6 = 1;
              }
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
              __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L14_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            }
            if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 88, __pyx_L14_error)
            __pyx_t_15 = ((PyArrayObject *)__pyx_t_2);
            {
              __Pyx_BufFmt_StackElem __pyx_stack[1];
              __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer);
              __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer, (PyObject*)__pyx_t_15, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
              if (unlikely(__pyx_t_6 < 0)) {
                PyErr_Fetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
                if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer, (PyObject*)__pyx_v_particles_not_set, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
                  Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_18);
                  __Pyx_RaiseBufferFallbackError();
                } else {
                  PyErr_Restore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
                }
                __pyx_t_16 = __pyx_t_17 = __pyx_t_18 = 0;
              }
              __pyx_pybuffernd_particles_not_set.diminfo[0].strides = __pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_particles_not_set.diminfo[0].shape = __pyx_pybuffernd_particles_not_set.rcbuffer->pybuffer.shape[0];
              if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 88, __pyx_L14_error)
            }
            __pyx_t_15 = 0;
            __Pyx_XDECREF_SET(__pyx_v_particles_not_set, ((PyArrayObject *)__pyx_t_2));
            __pyx_t_2 = 0;

+089:             with nogil:

            {
                #ifdef WITH_THREAD
                PyThreadState *_save;
                _save = NULL;
                Py_UNBLOCK_THREADS
                __Pyx_FastGIL_Remember();
                #endif
                /*try:*/ {
/* … */
                /*finally:*/ {
                  /*normal exit:*/{
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L26;
                  }
                  __pyx_L25_error: {
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L14_error;
                  }
                  __pyx_L26:;
                }
            }

+090:                 for p in prange(particles_not_set.shape[0]):

                  __pyx_t_19 = __pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_particles_not_set)); if (unlikely(__pyx_t_19 == ((npy_intp *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 90, __pyx_L25_error)
                  __pyx_t_20 = (__pyx_t_19[0]);
                  {
                      #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                          #undef likely
                          #undef unlikely
                          #define likely(x)   (x)
                          #define unlikely(x) (x)
                      #endif
                      __pyx_t_22 = (__pyx_t_20 - 0 + 1 - 1/abs(1)) / 1;
                      if (__pyx_t_22 > 0)
                      {
                          #ifdef _OPENMP
                          #pragma omp parallel
                          #endif /* _OPENMP */
                          {
                              #ifdef _OPENMP
                              #pragma omp for firstprivate(__pyx_v_p) lastprivate(__pyx_v_p)
                              #endif /* _OPENMP */
                              for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_22; __pyx_t_21++){
                                  {
                                      __pyx_v_p = (int)(0 + 1 * __pyx_t_21);

+091:                     _get_particle_candidate(_image_pdf, p, _xp, _yp, _min_distance)  # find some particles

                                      __pyx_t_1 = __pyx_f_7nanopyx_4core_8generate_23simulate_particle_field__get_particle_candidate(__pyx_v__image_pdf, __pyx_v_p, __pyx_v__xp, __pyx_v__yp, __pyx_v__min_distance); if (unlikely(__pyx_t_1 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 91, __pyx_L29_error)
                                      goto __pyx_L32;
                                      __pyx_L29_error:;
                                      {
                                          #ifdef WITH_THREAD
                                          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                                          #endif
                                          #ifdef _OPENMP
                                          #pragma omp flush(__pyx_parallel_exc_type)
                                          #endif /* _OPENMP */
                                          if (!__pyx_parallel_exc_type) {
                                            __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
                                            __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
                                            __Pyx_GOTREF(__pyx_parallel_exc_type);
                                          }
                                          #ifdef WITH_THREAD
                                          __Pyx_PyGILState_Release(__pyx_gilstate_save);
                                          #endif
                                      }
                                      __pyx_parallel_why = 4;
                                      goto __pyx_L31;
                                      __pyx_L31:;
                                      #ifdef _OPENMP
                                      #pragma omp critical(__pyx_parallel_lastprivates4)
                                      #endif /* _OPENMP */
                                      {
                                          __pyx_parallel_temp0 = __pyx_v_p;
                                      }
                                      __pyx_L32:;
                                      #ifdef _OPENMP
                                      #pragma omp flush(__pyx_parallel_why)
                                      #endif /* _OPENMP */
                                  }
                              }
                              #ifdef _OPENMP
                              Py_END_ALLOW_THREADS
                              #else
{
#ifdef WITH_THREAD
                              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                              #endif
                              #endif /* _OPENMP */
                              /* Clean up any temporaries */
                              #ifdef WITH_THREAD
                              __Pyx_PyGILState_Release(__pyx_gilstate_save);
                              #endif
                              #ifndef _OPENMP
}
#endif /* _OPENMP */
                          }
                      }
                      if (__pyx_parallel_exc_type) {
                        /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
                        __pyx_parallel_why = 4;
                      }
                      if (__pyx_parallel_why) {
                        __pyx_v_p = __pyx_parallel_temp0;
                        switch (__pyx_parallel_why) {
                              case 4:
                          {
                              #ifdef WITH_THREAD
                              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                              #endif
                              __Pyx_GIVEREF(__pyx_parallel_exc_type);
                              __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
                              __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
                              #ifdef WITH_THREAD
                              __Pyx_PyGILState_Release(__pyx_gilstate_save);
                              #endif
                          }
                          goto __pyx_L25_error;
                        }
                      }
                  }
                  #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                      #undef likely
                      #undef unlikely
                      #define likely(x)   __builtin_expect(!!(x), 1)
                      #define unlikely(x) __builtin_expect(!!(x), 0)
                  #endif
                }

+092:             particles_set = np.nonzero(xp >= 0)[0].astype(np.int32)  # get the index for the parciles already set

            __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 92, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_nonzero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 92, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_7);
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_8 = PyObject_RichCompare(__pyx_v_xp, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 92, __pyx_L14_error)
            __pyx_t_3 = NULL;
            __pyx_t_6 = 0;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_7))) {
              __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
              if (likely(__pyx_t_3)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
                __Pyx_INCREF(__pyx_t_3);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_7, function);
                __pyx_t_6 = 1;
              }
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8};
              __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 92, __pyx_L14_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            }
            __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 92, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_7);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 92, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 92, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_7);
            __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int32); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 92, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
            __pyx_t_7 = NULL;
            __pyx_t_6 = 0;
            #if CYTHON_UNPACK_METHODS
            if (likely(PyMethod_Check(__pyx_t_4))) {
              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
              if (likely(__pyx_t_7)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
                __Pyx_INCREF(__pyx_t_7);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_4, function);
                __pyx_t_6 = 1;
              }
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
              __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L14_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            }
            if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 92, __pyx_L14_error)
            __pyx_t_15 = ((PyArrayObject *)__pyx_t_2);
            {
              __Pyx_BufFmt_StackElem __pyx_stack[1];
              __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer);
              __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer, (PyObject*)__pyx_t_15, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
              if (unlikely(__pyx_t_6 < 0)) {
                PyErr_Fetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
                if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer, (PyObject*)__pyx_v_particles_set, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
                  Py_XDECREF(__pyx_t_18); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_16);
                  __Pyx_RaiseBufferFallbackError();
                } else {
                  PyErr_Restore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
                }
                __pyx_t_18 = __pyx_t_17 = __pyx_t_16 = 0;
              }
              __pyx_pybuffernd_particles_set.diminfo[0].strides = __pyx_pybuffernd_particles_set.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_particles_set.diminfo[0].shape = __pyx_pybuffernd_particles_set.rcbuffer->pybuffer.shape[0];
              if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 92, __pyx_L14_error)
            }
            __pyx_t_15 = 0;
            __Pyx_XDECREF_SET(__pyx_v_particles_set, ((PyArrayObject *)__pyx_t_2));
            __pyx_t_2 = 0;

+093:             with nogil:

            {
                #ifdef WITH_THREAD
                PyThreadState *_save;
                _save = NULL;
                Py_UNBLOCK_THREADS
                __Pyx_FastGIL_Remember();
                #endif
                /*try:*/ {
/* … */
                /*finally:*/ {
                  /*normal exit:*/{
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L37;
                  }
                  __pyx_L34_break: {
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L21_break;
                  }
                  __pyx_L36_error: {
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L14_error;
                  }
                  __pyx_L37:;
                }
            }

+094:                 n_particles = 0

                  __pyx_v_n_particles = 0;

+095:                 closest_distance_sum = 0

                  __pyx_v_closest_distance_sum = 0.0;

+096:                 for p in prange(particles_set.shape[0]):

                  __pyx_t_19 = __pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_particles_set)); if (unlikely(__pyx_t_19 == ((npy_intp *)NULL) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 96, __pyx_L36_error)
                  __pyx_t_22 = (__pyx_t_19[0]);
                  {
                      #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                          #undef likely
                          #undef unlikely
                          #define likely(x)   (x)
                          #define unlikely(x) (x)
                      #endif
                      __pyx_t_20 = (__pyx_t_22 - 0 + 1 - 1/abs(1)) / 1;
                      if (__pyx_t_20 > 0)
                      {
                          #ifdef _OPENMP
                          #pragma omp parallel
                          #endif /* _OPENMP */
                          {
                              #ifdef _OPENMP
                              #pragma omp for lastprivate(__pyx_v_closest_distance) reduction(+:__pyx_v_closest_distance_sum) reduction(+:__pyx_v_n_particles) firstprivate(__pyx_v_p) lastprivate(__pyx_v_p)
                              #endif /* _OPENMP */
                              for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21++){
                                  {
                                      __pyx_v_p = (int)(0 + 1 * __pyx_t_21);
                                      /* Initialize private variables to invalid values */
                                      __pyx_v_closest_distance = ((float)__PYX_NAN());

+097:                     closest_distance = _get_closest_distance(_xp[p], _yp[p], _xp, _yp)

                                      __pyx_t_23 = __pyx_v_p;
                                      __pyx_t_24 = __pyx_v_p;
                                      __pyx_t_25 = __pyx_f_7nanopyx_4core_8generate_23simulate_particle_field__get_closest_distance((*((float *) ( /* dim=0 */ (__pyx_v__xp.data + __pyx_t_23 * __pyx_v__xp.strides[0]) ))), (*((float *) ( /* dim=0 */ (__pyx_v__yp.data + __pyx_t_24 * __pyx_v__yp.strides[0]) ))), __pyx_v__xp, __pyx_v__yp); if (unlikely(__pyx_t_25 == ((double)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 97, __pyx_L40_error)
                                      __pyx_v_closest_distance = __pyx_t_25;

+098:                     if closest_distance < _min_distance:  # kickout particles found too close

                                      __pyx_t_1 = (__pyx_v_closest_distance < __pyx_v__min_distance);
                                      if (__pyx_t_1) {
/* … */
                                        goto __pyx_L42;
                                      }

+099:                         _xp[p] = -999999

                                        __pyx_t_24 = __pyx_v_p;
                                        *((float *) ( /* dim=0 */ (__pyx_v__xp.data + __pyx_t_24 * __pyx_v__xp.strides[0]) )) = -999999.0;

+100:                         _yp[p] = -999999

                                        __pyx_t_24 = __pyx_v_p;
                                        *((float *) ( /* dim=0 */ (__pyx_v__yp.data + __pyx_t_24 * __pyx_v__yp.strides[0]) )) = -999999.0;

 101:                     else:  # count the particles that are not kicked out

+102:                         closest_distance_sum += closest_distance

                                      /*else*/ {
                                        __pyx_v_closest_distance_sum = (__pyx_v_closest_distance_sum + __pyx_v_closest_distance);

+103:                         n_particles += 1

                                        __pyx_v_n_particles = (__pyx_v_n_particles + 1);
                                      }
                                      __pyx_L42:;
                                      goto __pyx_L44;
                                      __pyx_L40_error:;
                                      {
                                          #ifdef WITH_THREAD
                                          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                                          #endif
                                          #ifdef _OPENMP
                                          #pragma omp flush(__pyx_parallel_exc_type)
                                          #endif /* _OPENMP */
                                          if (!__pyx_parallel_exc_type) {
                                            __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
                                            __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
                                            __Pyx_GOTREF(__pyx_parallel_exc_type);
                                          }
                                          #ifdef WITH_THREAD
                                          __Pyx_PyGILState_Release(__pyx_gilstate_save);
                                          #endif
                                      }
                                      __pyx_parallel_why = 4;
                                      goto __pyx_L43;
                                      __pyx_L43:;
                                      #ifdef _OPENMP
                                      #pragma omp critical(__pyx_parallel_lastprivates5)
                                      #endif /* _OPENMP */
                                      {
                                          __pyx_parallel_temp0 = __pyx_v_closest_distance;
                                          __pyx_parallel_temp1 = __pyx_v_closest_distance_sum;
                                          __pyx_parallel_temp2 = __pyx_v_n_particles;
                                          __pyx_parallel_temp3 = __pyx_v_p;
                                      }
                                      __pyx_L44:;
                                      #ifdef _OPENMP
                                      #pragma omp flush(__pyx_parallel_why)
                                      #endif /* _OPENMP */
                                  }
                              }
                              #ifdef _OPENMP
                              Py_END_ALLOW_THREADS
                              #else
{
#ifdef WITH_THREAD
                              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                              #endif
                              #endif /* _OPENMP */
                              /* Clean up any temporaries */
                              #ifdef WITH_THREAD
                              __Pyx_PyGILState_Release(__pyx_gilstate_save);
                              #endif
                              #ifndef _OPENMP
}
#endif /* _OPENMP */
                          }
                      }
                      if (__pyx_parallel_exc_type) {
                        /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
                        __pyx_parallel_why = 4;
                      }
                      if (__pyx_parallel_why) {
                        __pyx_v_closest_distance = __pyx_parallel_temp0;
                        __pyx_v_closest_distance_sum = __pyx_parallel_temp1;
                        __pyx_v_n_particles = __pyx_parallel_temp2;
                        __pyx_v_p = __pyx_parallel_temp3;
                        switch (__pyx_parallel_why) {
                              case 4:
                          {
                              #ifdef WITH_THREAD
                              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                              #endif
                              __Pyx_GIVEREF(__pyx_parallel_exc_type);
                              __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
                              __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
                              #ifdef WITH_THREAD
                              __Pyx_PyGILState_Release(__pyx_gilstate_save);
                              #endif
                          }
                          goto __pyx_L36_error;
                        }
                      }
                  }
                  #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                      #undef likely
                      #undef unlikely
                      #define likely(x)   __builtin_expect(!!(x), 1)
                      #define unlikely(x) __builtin_expect(!!(x), 0)
                  #endif

 104:

 105:                 # calculate the mean distance

+106:                 if n_particles > 0:

                  __pyx_t_1 = (__pyx_v_n_particles > 0);
                  if (__pyx_t_1) {
/* … */
                  }

+107:                     mean_closest_distance = closest_distance_sum / n_particles

                    __pyx_v_mean_closest_distance = (__pyx_v_closest_distance_sum / ((float)__pyx_v_n_particles));

 108:

 109:                 # check if the number of particles changed, if not increment the number of tries

+110:                 if n_particles == previous_n_particles:

                  __pyx_t_1 = (__pyx_v_n_particles == __pyx_v_previous_n_particles);
                  if (__pyx_t_1) {
/* … */
                    goto __pyx_L46;
                  }

+111:                     tries += 1

                    __pyx_v_tries = (__pyx_v_tries + 1);

 112:                 else:

+113:                     tries = 0

                  /*else*/ {
                    __pyx_v_tries = 0;
                  }
                  __pyx_L46:;

 114:

 115:                 # too many tries without change in the number of parciles

+116:                 if n_particles == _max_particles or tries == _max_tries:

                  __pyx_t_5 = (__pyx_v_n_particles == __pyx_v__max_particles);
                  if (!__pyx_t_5) {
                  } else {
                    __pyx_t_1 = __pyx_t_5;
                    goto __pyx_L48_bool_binop_done;
                  }
                  __pyx_t_5 = (__pyx_v_tries == __pyx_v__max_tries);
                  __pyx_t_1 = __pyx_t_5;
                  __pyx_L48_bool_binop_done:;
                  if (__pyx_t_1) {
/* … */
                  }

+117:                     break

                    goto __pyx_L34_break;

 118:

 119:                 # check if the mean distance is below the threshold

+120:                 if _mean_distance_threshold > 0 and n_particles > _min_particles and mean_closest_distance < _mean_distance_threshold:

                  __pyx_t_5 = (__pyx_v__mean_distance_threshold > 0.0);
                  if (__pyx_t_5) {
                  } else {
                    __pyx_t_1 = __pyx_t_5;
                    goto __pyx_L51_bool_binop_done;
                  }
                  __pyx_t_5 = (__pyx_v_n_particles > __pyx_v__min_particles);
                  if (__pyx_t_5) {
                  } else {
                    __pyx_t_1 = __pyx_t_5;
                    goto __pyx_L51_bool_binop_done;
                  }
                  __pyx_t_5 = (__pyx_v_mean_closest_distance < __pyx_v__mean_distance_threshold);
                  __pyx_t_1 = __pyx_t_5;
                  __pyx_L51_bool_binop_done:;
                  if (__pyx_t_1) {
/* … */
                  }
                }

+121:                     break

                    goto __pyx_L34_break;

 122:

+123:             progress_bar.update(n_particles-previous_n_particles)

            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_progress_bar, __pyx_n_s_update); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_8 = __Pyx_PyInt_From_int((__pyx_v_n_particles - __pyx_v_previous_n_particles)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 123, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_7 = NULL;
            __pyx_t_6 = 0;
            #if CYTHON_UNPACK_METHODS
            if (likely(PyMethod_Check(__pyx_t_4))) {
              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
              if (likely(__pyx_t_7)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
                __Pyx_INCREF(__pyx_t_7);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_4, function);
                __pyx_t_6 = 1;
              }
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
              __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L14_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            }
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+124:             previous_n_particles = n_particles

            __pyx_v_previous_n_particles = __pyx_v_n_particles;
          }
          __pyx_L21_break:;

 125:

 126:     # keep only set particles

+127:     particles_set = np.nonzero(xp >= 0)[0].astype(np.int32)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_nonzero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyObject_RichCompare(__pyx_v_xp, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 127, __pyx_L1_error)
  __pyx_t_3 = NULL;
  __pyx_t_6 = 0;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_7))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_7, function);
      __pyx_t_6 = 1;
    }
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2};
    __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 127, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  }
  __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = NULL;
  __pyx_t_6 = 0;
  #if CYTHON_UNPACK_METHODS
  if (likely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
      __pyx_t_6 = 1;
    }
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_2};
    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 127, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  }
  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 127, __pyx_L1_error)
  __pyx_t_15 = ((PyArrayObject *)__pyx_t_8);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer);
    __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer, (PyObject*)__pyx_t_15, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
    if (unlikely(__pyx_t_6 < 0)) {
      PyErr_Fetch(&__pyx_t_11, &__pyx_t_14, &__pyx_t_13);
      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_particles_set.rcbuffer->pybuffer, (PyObject*)__pyx_v_particles_set, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
        Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_13);
        __Pyx_RaiseBufferFallbackError();
      } else {
        PyErr_Restore(__pyx_t_11, __pyx_t_14, __pyx_t_13);
      }
      __pyx_t_11 = __pyx_t_14 = __pyx_t_13 = 0;
    }
    __pyx_pybuffernd_particles_set.diminfo[0].strides = __pyx_pybuffernd_particles_set.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_particles_set.diminfo[0].shape = __pyx_pybuffernd_particles_set.rcbuffer->pybuffer.shape[0];
    if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 127, __pyx_L1_error)
  }
  __pyx_t_15 = 0;
  __Pyx_XDECREF_SET(__pyx_v_particles_set, ((PyArrayObject *)__pyx_t_8));
  __pyx_t_8 = 0;

+128:     xp = xp[particles_set]

  __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_xp, ((PyObject *)__pyx_v_particles_set)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF_SET(__pyx_v_xp, __pyx_t_8);
  __pyx_t_8 = 0;

+129:     yp = yp[particles_set]

  __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_yp, ((PyObject *)__pyx_v_particles_set)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF_SET(__pyx_v_yp, __pyx_t_8);
  __pyx_t_8 = 0;

 130:

+131:     return np.array([xp, yp]).T, mean_closest_distance

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_v_xp);
  __Pyx_GIVEREF(__pyx_v_xp);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_v_xp)) __PYX_ERR(0, 131, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_yp);
  __Pyx_GIVEREF(__pyx_v_yp);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_v_yp)) __PYX_ERR(0, 131, __pyx_L1_error);
  __pyx_t_7 = NULL;
  __pyx_t_6 = 0;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
      __pyx_t_6 = 1;
    }
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4};
    __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 131, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_T); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_mean_closest_distance); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8)) __PYX_ERR(0, 131, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_8 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 132:

 133:

+134: cdef bint _get_particle_candidate(float[:, :] _image_pdf, int particle_index, float[:] xp, float[:] yp, float min_distance) nogil:

static int __pyx_f_7nanopyx_4core_8generate_23simulate_particle_field__get_particle_candidate(__Pyx_memviewslice __pyx_v__image_pdf, int __pyx_v_particle_index, __Pyx_memviewslice __pyx_v_xp, __Pyx_memviewslice __pyx_v_yp, float __pyx_v_min_distance) {
  float __pyx_v_x;
  float __pyx_v_y;
  float __pyx_v_pdf;
  float __pyx_v_r;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_get_particle_candidate", 1);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  #ifdef WITH_THREAD
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field._get_particle_candidate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

 135:     """

 136:     Get a particle candidate by sampling the image PDF and placing a particle at a point with a probability that is proportional to the PDF at that point.

 137:     :param _image_pdf: 2D array of floats, the PDF

 138:     :param particle_index: int, the index of the particle to place

 139:     :param xp: 1D array of floats, the x coordinates of the particles

 140:     :param yp: 1D array of floats, the y coordinates of the particles

 141:     :param min_distance: float, ensure that particle distances are above minimum distance given

 142:     :return: 1 if a particle was placed, 0 if not

 143:     """

 144:

+145:     cdef float x = _random() * (_image_pdf.shape[1] - 1)

  __pyx_t_1 = __pyx_f_7nanopyx_4core_5utils_6random__random(); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 145, __pyx_L1_error)
  __pyx_v_x = (__pyx_t_1 * ((__pyx_v__image_pdf.shape[1]) - 1));

+146:     cdef float y = _random() * (_image_pdf.shape[0] - 1)

  __pyx_t_1 = __pyx_f_7nanopyx_4core_5utils_6random__random(); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 146, __pyx_L1_error)
  __pyx_v_y = (__pyx_t_1 * ((__pyx_v__image_pdf.shape[0]) - 1));

+147:     cdef float pdf = _interpolate(_image_pdf, x, y)

  __pyx_t_2 = __pyx_f_7nanopyx_4core_9transform_25interpolation_catmull_rom__interpolate(__pyx_v__image_pdf, __pyx_v_x, __pyx_v_y); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 147, __pyx_L1_error)
  __pyx_v_pdf = __pyx_t_2;

+148:     cdef float r = _random()

  __pyx_t_1 = __pyx_f_7nanopyx_4core_5utils_6random__random(); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 148, __pyx_L1_error)
  __pyx_v_r = __pyx_t_1;

 149:

+150:     if r < pdf and _get_closest_distance(x, y, xp, yp) > min_distance:

  __pyx_t_4 = (__pyx_v_r < __pyx_v_pdf);
  if (__pyx_t_4) {
  } else {
    __pyx_t_3 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_1 = __pyx_f_7nanopyx_4core_8generate_23simulate_particle_field__get_closest_distance(__pyx_v_x, __pyx_v_y, __pyx_v_xp, __pyx_v_yp); if (unlikely(__pyx_t_1 == ((double)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 150, __pyx_L1_error)
  __pyx_t_4 = (__pyx_t_1 > __pyx_v_min_distance);
  __pyx_t_3 = __pyx_t_4;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_3) {
/* … */
  }

+151:         xp[particle_index] = x

    __pyx_t_5 = __pyx_v_particle_index;
    *((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_5 * __pyx_v_xp.strides[0]) )) = __pyx_v_x;

+152:         yp[particle_index] = y

    __pyx_t_5 = __pyx_v_particle_index;
    *((float *) ( /* dim=0 */ (__pyx_v_yp.data + __pyx_t_5 * __pyx_v_yp.strides[0]) )) = __pyx_v_y;

+153:         return 1

    __pyx_r = 1;
    goto __pyx_L0;

 154:

+155:     return 0

  __pyx_r = 0;
  goto __pyx_L0;

 156:

 157:

+158: cdef double _get_closest_distance(float x, float y, float[:] xp, float[:] yp) nogil:

static double __pyx_f_7nanopyx_4core_8generate_23simulate_particle_field__get_closest_distance(float __pyx_v_x, float __pyx_v_y, __Pyx_memviewslice __pyx_v_xp, __Pyx_memviewslice __pyx_v_yp) {
  float __pyx_v__x;
  float __pyx_v__y;
  float __pyx_v__min_distance;
  Py_ssize_t __pyx_v_i;
  double __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 159:     """

 160:     Get the closest distance between a point and a set of particles.

 161:     Ignores particles with exact same location as x, y.

 162:     :param x: float, the x coordinate of the point

 163:     :param y: float, the y coordinate of the point

 164:     :param xp: 1D array of floats, the x coordinates of the particles

 165:     :param yp: 1D array of floats, the y coordinates of the particles

 166:     :return: double, the closest distance between the point and the particles

 167:     """

 168:

 169:     cdef float _x, _y

+170:     cdef float _min_distance = 999999999999

  __pyx_v__min_distance = 999999999999.0;

 171:

+172:     for i in range(xp.shape[0]):

  __pyx_t_1 = (__pyx_v_xp.shape[0]);
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

+173:         _x = xp[i]

    __pyx_t_4 = __pyx_v_i;
    __pyx_v__x = (*((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_4 * __pyx_v_xp.strides[0]) )));

+174:         _y = yp[i]

    __pyx_t_4 = __pyx_v_i;
    __pyx_v__y = (*((float *) ( /* dim=0 */ (__pyx_v_yp.data + __pyx_t_4 * __pyx_v_yp.strides[0]) )));

 175:

+176:         if _x < 0 or (x == _x and y == _y) or fabs(_x - x) > _min_distance or fabs(_y - y) > _min_distance:

    __pyx_t_6 = (__pyx_v__x < 0.0);
    if (!__pyx_t_6) {
    } else {
      __pyx_t_5 = __pyx_t_6;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_6 = (__pyx_v_x == __pyx_v__x);
    if (!__pyx_t_6) {
      goto __pyx_L8_next_or;
    } else {
    }
    __pyx_t_6 = (__pyx_v_y == __pyx_v__y);
    if (!__pyx_t_6) {
    } else {
      __pyx_t_5 = __pyx_t_6;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_L8_next_or:;
    __pyx_t_6 = (fabs((__pyx_v__x - __pyx_v_x)) > __pyx_v__min_distance);
    if (!__pyx_t_6) {
    } else {
      __pyx_t_5 = __pyx_t_6;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_6 = (fabs((__pyx_v__y - __pyx_v_y)) > __pyx_v__min_distance);
    __pyx_t_5 = __pyx_t_6;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_5) {
/* … */
    }

+177:             continue

      goto __pyx_L3_continue;

 178:

+179:         _min_distance = min(_min_distance, sqrt((_x - x) ** 2 + (_y - y) ** 2))

    __pyx_t_7 = sqrt((powf((__pyx_v__x - __pyx_v_x), 2.0) + powf((__pyx_v__y - __pyx_v_y), 2.0)));
    __pyx_t_8 = __pyx_v__min_distance;
    __pyx_t_5 = (__pyx_t_7 < __pyx_t_8);
    if (__pyx_t_5) {
      __pyx_t_9 = __pyx_t_7;
    } else {
      __pyx_t_9 = __pyx_t_8;
    }
    __pyx_v__min_distance = __pyx_t_9;
    __pyx_L3_continue:;
  }

 180:

+181:     return _min_distance

  __pyx_r = __pyx_v__min_distance;
  goto __pyx_L0;

 182:

 183:

+184: def get_closest_distance(float[:,:] particle_field):

/* Python wrapper */
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_3get_closest_distance(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_2get_closest_distance, "\n    Get the closest distance between all particles\n    :param particle_field: 2D array of floats, the particle field\n    :return: double, the closest distance between all particles\n    ");
static PyMethodDef __pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_3get_closest_distance = {"get_closest_distance", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_3get_closest_distance, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_2get_closest_distance};
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_3get_closest_distance(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __Pyx_memviewslice __pyx_v_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_closest_distance (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_MACROS
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args);
  if (unlikely((__pyx_nargs < 0))) __PYX_ERR(0, 184, __pyx_L3_error)
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_particle_field,0};
  PyObject* values[1] = {0};
    if (__pyx_kwds) {
      Py_ssize_t kw_args;
      switch (__pyx_nargs) {
        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
      switch (__pyx_nargs) {
        case  0:
        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_particle_field)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 184, __pyx_L3_error)
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        const Py_ssize_t kwd_pos_args = __pyx_nargs;
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_closest_distance") < 0)) __PYX_ERR(0, 184, __pyx_L3_error)
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
    }
    __pyx_v_particle_field = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_particle_field.memview)) __PYX_ERR(0, 184, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("get_closest_distance", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 184, __pyx_L3_error)
  goto __pyx_L3_error;
  __pyx_L3_error:;
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.get_closest_distance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_2get_closest_distance(__pyx_self, __pyx_v_particle_field);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_2get_closest_distance(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_particle_field) {
  __Pyx_memviewslice __pyx_v_xp = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_yp = { 0, 0, { 0 }, { 0 }, { 0 } };
  float __pyx_v_closest_distance;
  int __pyx_v_p;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_closest_distance", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.get_closest_distance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_xp, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_yp, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__28 = PyTuple_Pack(5, __pyx_n_s_particle_field, __pyx_n_s_xp, __pyx_n_s_yp, __pyx_n_s_closest_distance, __pyx_n_s_p); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 184, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__28);
  __Pyx_GIVEREF(__pyx_tuple__28);
/* … */
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_3get_closest_distance, 0, __pyx_n_s_get_closest_distance, NULL, __pyx_n_s_nanopyx_core_generate_simulate_p, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_closest_distance, __pyx_t_7) < 0) __PYX_ERR(0, 184, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_nanopyx_core_generate_simula, __pyx_n_s_get_closest_distance, 184, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 184, __pyx_L1_error)

 185:     """

 186:     Get the closest distance between all particles

 187:     :param particle_field: 2D array of floats, the particle field

 188:     :return: double, the closest distance between all particles

 189:     """

 190:

+191:     cdef float[:] xp = particle_field[:, 0]

  __pyx_t_1.data = __pyx_v_particle_field.data;
  __pyx_t_1.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_1, 1);
  __pyx_t_1.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_1.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_1.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 0;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_1.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_xp = __pyx_t_1;
  __pyx_t_1.memview = NULL;
  __pyx_t_1.data = NULL;

+192:     cdef float[:] yp = particle_field[:, 1]

  __pyx_t_1.data = __pyx_v_particle_field.data;
  __pyx_t_1.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_1, 1);
  __pyx_t_1.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_1.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_1.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 1;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_1.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_yp = __pyx_t_1;
  __pyx_t_1.memview = NULL;
  __pyx_t_1.data = NULL;

 193:

+194:     cdef float closest_distance = 999999999999

  __pyx_v_closest_distance = 999999999999.0;

 195:     cdef int p

 196:

+197:     with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      _save = NULL;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L5;
        }
        __pyx_L4_error: {
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L1_error;
        }
        __pyx_L5:;
      }
  }

+198:         for p in range(xp.shape[0]):

        __pyx_t_2 = (__pyx_v_xp.shape[0]);
        __pyx_t_3 = __pyx_t_2;
        for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
          __pyx_v_p = __pyx_t_4;

+199:             if xp[p] < 0:

          __pyx_t_5 = __pyx_v_p;
          __pyx_t_6 = ((*((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_5 * __pyx_v_xp.strides[0]) ))) < 0.0);
          if (__pyx_t_6) {
/* … */
          }

+200:                 continue

            goto __pyx_L6_continue;

+201:             closest_distance = min(closest_distance, _get_closest_distance(xp[p], yp[p], xp, yp))

          __pyx_t_5 = __pyx_v_p;
          __pyx_t_7 = __pyx_v_p;
          __pyx_t_8 = __pyx_f_7nanopyx_4core_8generate_23simulate_particle_field__get_closest_distance((*((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_5 * __pyx_v_xp.strides[0]) ))), (*((float *) ( /* dim=0 */ (__pyx_v_yp.data + __pyx_t_7 * __pyx_v_yp.strides[0]) ))), __pyx_v_xp, __pyx_v_yp); if (unlikely(__pyx_t_8 == ((double)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 201, __pyx_L4_error)
          __pyx_t_9 = __pyx_v_closest_distance;
          __pyx_t_6 = (__pyx_t_8 < __pyx_t_9);
          if (__pyx_t_6) {
            __pyx_t_10 = __pyx_t_8;
          } else {
            __pyx_t_10 = __pyx_t_9;
          }
          __pyx_v_closest_distance = __pyx_t_10;
          __pyx_L6_continue:;
        }
      }

 202:

+203:     return closest_distance

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_11 = PyFloat_FromDouble(__pyx_v_closest_distance); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_r = __pyx_t_11;
  __pyx_t_11 = 0;
  goto __pyx_L0;

 204:

 205:

+206: def render_particle_histogram(float[:,:] particle_field, int h, int w, double amplitude, double sigma_x, double sigma_y):

/* Python wrapper */
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_5render_particle_histogram(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_4render_particle_histogram, "\n    Render a particle field as an image\n    :param particle_field: 2D array of floats, the particle field with shape (n_particles, 2) where the last dimension is the x and y coordinates of the particle\n    :param w: int, the width of the image\n    :param h: int, the height of the image\n    :return: 2D array of floats, the rendered particle field\n    ");
static PyMethodDef __pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_5render_particle_histogram = {"render_particle_histogram", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_5render_particle_histogram, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_4render_particle_histogram};
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_5render_particle_histogram(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __Pyx_memviewslice __pyx_v_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_h;
  int __pyx_v_w;
  double __pyx_v_amplitude;
  double __pyx_v_sigma_x;
  double __pyx_v_sigma_y;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("render_particle_histogram (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_MACROS
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args);
  if (unlikely((__pyx_nargs < 0))) __PYX_ERR(0, 206, __pyx_L3_error)
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_particle_field,&__pyx_n_s_h,&__pyx_n_s_w,&__pyx_n_s_amplitude,&__pyx_n_s_sigma_x,&__pyx_n_s_sigma_y,0};
  PyObject* values[6] = {0,0,0,0,0,0};
    if (__pyx_kwds) {
      Py_ssize_t kw_args;
      switch (__pyx_nargs) {
        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
      switch (__pyx_nargs) {
        case  0:
        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_particle_field)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_h)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram", 1, 6, 6, 1); __PYX_ERR(0, 206, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_w)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram", 1, 6, 6, 2); __PYX_ERR(0, 206, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_amplitude)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram", 1, 6, 6, 3); __PYX_ERR(0, 206, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sigma_x)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram", 1, 6, 6, 4); __PYX_ERR(0, 206, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sigma_y)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram", 1, 6, 6, 5); __PYX_ERR(0, 206, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        const Py_ssize_t kwd_pos_args = __pyx_nargs;
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "render_particle_histogram") < 0)) __PYX_ERR(0, 206, __pyx_L3_error)
      }
    } else if (unlikely(__pyx_nargs != 6)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);
    }
    __pyx_v_particle_field = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_particle_field.memview)) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_h = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_w = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_w == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_amplitude = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_amplitude == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_sigma_x = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_sigma_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
    __pyx_v_sigma_y = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_sigma_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("render_particle_histogram", 1, 6, 6, __pyx_nargs); __PYX_ERR(0, 206, __pyx_L3_error)
  goto __pyx_L3_error;
  __pyx_L3_error:;
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_histogram", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_4render_particle_histogram(__pyx_self, __pyx_v_particle_field, __pyx_v_h, __pyx_v_w, __pyx_v_amplitude, __pyx_v_sigma_x, __pyx_v_sigma_y);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_4render_particle_histogram(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_particle_field, int __pyx_v_h, int __pyx_v_w, double __pyx_v_amplitude, double __pyx_v_sigma_x, double __pyx_v_sigma_y) {
  PyObject *__pyx_v_image_particle_field = NULL;
  __Pyx_memviewslice __pyx_v__image_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_n_particles;
  __Pyx_memviewslice __pyx_v_xp = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_yp = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_x;
  int __pyx_v_y;
  int __pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("render_particle_histogram", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_histogram", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_image_particle_field);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v__image_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_xp, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_yp, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__30 = PyTuple_Pack(14, __pyx_n_s_particle_field, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_amplitude, __pyx_n_s_sigma_x, __pyx_n_s_sigma_y, __pyx_n_s_image_particle_field, __pyx_n_s_image_particle_field_2, __pyx_n_s_n_particles, __pyx_n_s_xp, __pyx_n_s_yp, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_i); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__30);
  __Pyx_GIVEREF(__pyx_tuple__30);
/* … */
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_5render_particle_histogram, 0, __pyx_n_s_render_particle_histogram, NULL, __pyx_n_s_nanopyx_core_generate_simulate_p, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_render_particle_histogram, __pyx_t_7) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_nanopyx_core_generate_simula, __pyx_n_s_render_particle_histogram, 206, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 206, __pyx_L1_error)

 207:     """

 208:     Render a particle field as an image

 209:     :param particle_field: 2D array of floats, the particle field with shape (n_particles, 2) where the last dimension is the x and y coordinates of the particle

 210:     :param w: int, the width of the image

 211:     :param h: int, the height of the image

 212:     :return: 2D array of floats, the rendered particle field

 213:     """

 214:

+215:     image_particle_field = np.zeros((h, w), dtype=np.float32)

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_h); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_w); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_3);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_image_particle_field = __pyx_t_5;
  __pyx_t_5 = 0;

+216:     cdef float[:,:] _image_particle_field = image_particle_field

  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_image_particle_field, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 216, __pyx_L1_error)
  __pyx_v__image_particle_field = __pyx_t_6;
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;

 217:

+218:     cdef int n_particles = particle_field.shape[0]

  __pyx_v_n_particles = (__pyx_v_particle_field.shape[0]);

+219:     cdef float[:] xp = particle_field[:, 0]

  __pyx_t_7.data = __pyx_v_particle_field.data;
  __pyx_t_7.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_7.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_7.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 0;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_xp = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

+220:     cdef float[:] yp = particle_field[:, 1]

  __pyx_t_7.data = __pyx_v_particle_field.data;
  __pyx_t_7.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_7.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_7.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 1;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_yp = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 221:

 222:     cdef int x, y, i

 223:

+224:     with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      _save = NULL;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L5;
        }
        __pyx_L4_error: {
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L1_error;
        }
        __pyx_L5:;
      }
  }

+225:         for i in range(n_particles):

        __pyx_t_8 = __pyx_v_n_particles;
        __pyx_t_9 = __pyx_t_8;
        for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
          __pyx_v_i = __pyx_t_10;

+226:             x = int(xp[i])

          __pyx_t_11 = __pyx_v_i;
          __pyx_v_x = ((int)(*((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_11 * __pyx_v_xp.strides[0]) ))));

+227:             y = int(yp[i])

          __pyx_t_11 = __pyx_v_i;
          __pyx_v_y = ((int)(*((float *) ( /* dim=0 */ (__pyx_v_yp.data + __pyx_t_11 * __pyx_v_yp.strides[0]) ))));

+228:             if 0 <= x < w or 0 <= y < h:

          __pyx_t_13 = (0 <= __pyx_v_x);
          if (__pyx_t_13) {
            __pyx_t_13 = (__pyx_v_x < __pyx_v_w);
          }
          if (!__pyx_t_13) {
          } else {
            __pyx_t_12 = __pyx_t_13;
            goto __pyx_L9_bool_binop_done;
          }
          __pyx_t_13 = (0 <= __pyx_v_y);
          if (__pyx_t_13) {
            __pyx_t_13 = (__pyx_v_y < __pyx_v_h);
          }
          __pyx_t_12 = __pyx_t_13;
          __pyx_L9_bool_binop_done:;
          if (__pyx_t_12) {
/* … */
          }
        }
      }

 229:                 # _image_particle_field[y, x] += 1

+230:                 _image_particle_field = _render_erf_gaussian(_image_particle_field, x, y, amplitude, sigma_x, sigma_y)

            __pyx_t_6 = __pyx_f_7nanopyx_4core_8generate_19noise_add_gaussians__render_erf_gaussian(__pyx_v__image_particle_field, __pyx_v_x, __pyx_v_y, __pyx_v_amplitude, __pyx_v_sigma_x, __pyx_v_sigma_y); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 230, __pyx_L4_error)
            __PYX_XCLEAR_MEMVIEW(&__pyx_v__image_particle_field, 0);
            __pyx_v__image_particle_field = __pyx_t_6;
            __pyx_t_6.memview = NULL;
            __pyx_t_6.data = NULL;

 231:

+232:     return image_particle_field

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_image_particle_field);
  __pyx_r = __pyx_v_image_particle_field;
  goto __pyx_L0;

 233:

 234:

+235: def render_particle_histogram_with_tracks(float[:,:] particle_field, int[:,:] states, int h, int w):

/* Python wrapper */
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_7render_particle_histogram_with_tracks(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_6render_particle_histogram_with_tracks, "\n    Render a particle field as an image stack\n    :param particle_field: 2D array of floats, the particle field\n    :param states: 2D array of ints, the states of the particles\n    :param w: int, the width of the stack (in pixels)\n    :param h: int, the height of the stack (in pixels)\n    :return: 3D array of floats, the rendered particle field\n    ");
static PyMethodDef __pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_7render_particle_histogram_with_tracks = {"render_particle_histogram_with_tracks", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_7render_particle_histogram_with_tracks, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7nanopyx_4core_8generate_23simulate_particle_field_6render_particle_histogram_with_tracks};
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_7render_particle_histogram_with_tracks(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __Pyx_memviewslice __pyx_v_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_states = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_h;
  int __pyx_v_w;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("render_particle_histogram_with_tracks (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_MACROS
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args);
  if (unlikely((__pyx_nargs < 0))) __PYX_ERR(0, 235, __pyx_L3_error)
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_particle_field,&__pyx_n_s_states,&__pyx_n_s_h,&__pyx_n_s_w,0};
  PyObject* values[4] = {0,0,0,0};
    if (__pyx_kwds) {
      Py_ssize_t kw_args;
      switch (__pyx_nargs) {
        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
      switch (__pyx_nargs) {
        case  0:
        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_particle_field)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error)
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_states)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram_with_tracks", 1, 4, 4, 1); __PYX_ERR(0, 235, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_h)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram_with_tracks", 1, 4, 4, 2); __PYX_ERR(0, 235, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_w)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_histogram_with_tracks", 1, 4, 4, 3); __PYX_ERR(0, 235, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        const Py_ssize_t kwd_pos_args = __pyx_nargs;
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "render_particle_histogram_with_tracks") < 0)) __PYX_ERR(0, 235, __pyx_L3_error)
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
    }
    __pyx_v_particle_field = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_particle_field.memview)) __PYX_ERR(0, 235, __pyx_L3_error)
    __pyx_v_states = __Pyx_PyObject_to_MemoryviewSlice_dsds_int(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_states.memview)) __PYX_ERR(0, 235, __pyx_L3_error)
    __pyx_v_h = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error)
    __pyx_v_w = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_w == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("render_particle_histogram_with_tracks", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 235, __pyx_L3_error)
  goto __pyx_L3_error;
  __pyx_L3_error:;
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_states, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_histogram_with_tracks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_6render_particle_histogram_with_tracks(__pyx_self, __pyx_v_particle_field, __pyx_v_states, __pyx_v_h, __pyx_v_w);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_states, 1);
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_6render_particle_histogram_with_tracks(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_particle_field, __Pyx_memviewslice __pyx_v_states, int __pyx_v_h, int __pyx_v_w) {
  int __pyx_v_n_frames;
  PyObject *__pyx_v_image_particle_field = NULL;
  __Pyx_memviewslice __pyx_v__image_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  CYTHON_UNUSED int __pyx_v_n_particles;
  __Pyx_memviewslice __pyx_v_xp = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_yp = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_x;
  int __pyx_v_y;
  int __pyx_v_i;
  int __pyx_v_f;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("render_particle_histogram_with_tracks", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_histogram_with_tracks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_image_particle_field);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v__image_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_xp, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_yp, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__32 = PyTuple_Pack(14, __pyx_n_s_particle_field, __pyx_n_s_states, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_n_frames, __pyx_n_s_image_particle_field, __pyx_n_s_image_particle_field_2, __pyx_n_s_n_particles, __pyx_n_s_xp, __pyx_n_s_yp, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_i, __pyx_n_s_f); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__32);
  __Pyx_GIVEREF(__pyx_tuple__32);
/* … */
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_7render_particle_histogram_with_tracks, 0, __pyx_n_s_render_particle_histogram_with_t, NULL, __pyx_n_s_nanopyx_core_generate_simulate_p, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_render_particle_histogram_with_t, __pyx_t_7) < 0) __PYX_ERR(0, 235, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_nanopyx_core_generate_simula, __pyx_n_s_render_particle_histogram_with_t, 235, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 235, __pyx_L1_error)

 236:     """

 237:     Render a particle field as an image stack

 238:     :param particle_field: 2D array of floats, the particle field

 239:     :param states: 2D array of ints, the states of the particles

 240:     :param w: int, the width of the stack (in pixels)

 241:     :param h: int, the height of the stack (in pixels)

 242:     :return: 3D array of floats, the rendered particle field

 243:     """

 244:

+245:     assert particle_field.shape[0] == states.shape[0]

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = ((__pyx_v_particle_field.shape[0]) == (__pyx_v_states.shape[0]));
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 245, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 245, __pyx_L1_error)
  #endif

 246:

+247:     cdef int n_frames = states.shape[1]

  __pyx_v_n_frames = (__pyx_v_states.shape[1]);

 248:

+249:     image_particle_field = np.zeros((n_frames, h, w), dtype=np.float32)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_frames); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_h); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_w); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_image_particle_field = __pyx_t_2;
  __pyx_t_2 = 0;

+250:     cdef float[:,:,:] _image_particle_field = image_particle_field

  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_image_particle_field, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 250, __pyx_L1_error)
  __pyx_v__image_particle_field = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 251:

+252:     cdef int n_particles = particle_field.shape[0]

  __pyx_v_n_particles = (__pyx_v_particle_field.shape[0]);

+253:     cdef float[:] xp = particle_field[:, 0]

  __pyx_t_8.data = __pyx_v_particle_field.data;
  __pyx_t_8.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_8.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_8.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 0;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_8.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_xp = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

+254:     cdef float[:] yp = particle_field[:, 1]

  __pyx_t_8.data = __pyx_v_particle_field.data;
  __pyx_t_8.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_8.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_8.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 1;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_8.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_yp = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

 255:

 256:     cdef int x, y, i, f

 257:

+258:     with nogil:

  {
      #ifdef WITH_THREAD
      PyThreadState *_save;
      _save = NULL;
      Py_UNBLOCK_THREADS
      __Pyx_FastGIL_Remember();
      #endif
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          #ifdef WITH_THREAD
          __Pyx_FastGIL_Forget();
          Py_BLOCK_THREADS
          #endif
          goto __pyx_L5;
        }
        __pyx_L5:;
      }
  }

+259:         for i in prange(n_particles):

        __pyx_t_9 = __pyx_v_n_particles;
        {
            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                #undef likely
                #undef unlikely
                #define likely(x)   (x)
                #define unlikely(x) (x)
            #endif
            __pyx_t_11 = (__pyx_t_9 - 0 + 1 - 1/abs(1)) / 1;
            if (__pyx_t_11 > 0)
            {
                #ifdef _OPENMP
                #pragma omp parallel
                #endif /* _OPENMP */
                {
                    #ifdef _OPENMP
                    #pragma omp for lastprivate(__pyx_v_f) firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) lastprivate(__pyx_v_x) lastprivate(__pyx_v_y)
                    #endif /* _OPENMP */
                    for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_11; __pyx_t_10++){
                        {
                            __pyx_v_i = (int)(0 + 1 * __pyx_t_10);
                            /* Initialize private variables to invalid values */
                            __pyx_v_f = ((int)0xbad0bad0);
                            __pyx_v_x = ((int)0xbad0bad0);
                            __pyx_v_y = ((int)0xbad0bad0);

+260:             x = int(xp[i])

                            __pyx_t_12 = __pyx_v_i;
                            __pyx_v_x = ((int)(*((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_12 * __pyx_v_xp.strides[0]) ))));

+261:             y = int(yp[i])

                            __pyx_t_12 = __pyx_v_i;
                            __pyx_v_y = ((int)(*((float *) ( /* dim=0 */ (__pyx_v_yp.data + __pyx_t_12 * __pyx_v_yp.strides[0]) ))));

+262:             if 0 <= x < w or 0 <= y < h:

                            __pyx_t_13 = (0 <= __pyx_v_x);
                            if (__pyx_t_13) {
                              __pyx_t_13 = (__pyx_v_x < __pyx_v_w);
                            }
                            if (!__pyx_t_13) {
                            } else {
                              __pyx_t_1 = __pyx_t_13;
                              goto __pyx_L11_bool_binop_done;
                            }
                            __pyx_t_13 = (0 <= __pyx_v_y);
                            if (__pyx_t_13) {
                              __pyx_t_13 = (__pyx_v_y < __pyx_v_h);
                            }
                            __pyx_t_1 = __pyx_t_13;
                            __pyx_L11_bool_binop_done:;
                            if (__pyx_t_1) {
/* … */
                            }
                        }
                    }
                }
            }
        }
        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
            #undef likely
            #undef unlikely
            #define likely(x)   __builtin_expect(!!(x), 1)
            #define unlikely(x) __builtin_expect(!!(x), 0)
        #endif
      }

+263:                 for f in range(n_frames):

                              __pyx_t_14 = __pyx_v_n_frames;
                              __pyx_t_15 = __pyx_t_14;
                              for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
                                __pyx_v_f = __pyx_t_16;

+264:                     if states[i, f] == 1:

                                __pyx_t_12 = __pyx_v_i;
                                __pyx_t_17 = __pyx_v_f;
                                __pyx_t_1 = ((*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_states.data + __pyx_t_12 * __pyx_v_states.strides[0]) ) + __pyx_t_17 * __pyx_v_states.strides[1]) ))) == 1);
                                if (__pyx_t_1) {
/* … */
                                }
                              }

+265:                         _image_particle_field[f, y, x] += 1

                                  __pyx_t_17 = __pyx_v_f;
                                  __pyx_t_12 = __pyx_v_y;
                                  __pyx_t_18 = __pyx_v_x;
                                  *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v__image_particle_field.data + __pyx_t_17 * __pyx_v__image_particle_field.strides[0]) ) + __pyx_t_12 * __pyx_v__image_particle_field.strides[1]) ) + __pyx_t_18 * __pyx_v__image_particle_field.strides[2]) )) += 1.0;

 266:

+267:     return image_particle_field

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_image_particle_field);
  __pyx_r = __pyx_v_image_particle_field;
  goto __pyx_L0;

 268:

 269:

+270: def render_particle_gaussians_with_tracks(float[:,:] particle_field, int[:,:] states, int h, int w, double amplitude, double sigma_x, double sigma_y):

/* Python wrapper */
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_9render_particle_gaussians_with_tracks(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_9render_particle_gaussians_with_tracks = {"render_particle_gaussians_with_tracks", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_9render_particle_gaussians_with_tracks, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7nanopyx_4core_8generate_23simulate_particle_field_9render_particle_gaussians_with_tracks(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  __Pyx_memviewslice __pyx_v_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_states = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_h;
  int __pyx_v_w;
  double __pyx_v_amplitude;
  double __pyx_v_sigma_x;
  double __pyx_v_sigma_y;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("render_particle_gaussians_with_tracks (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_MACROS
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args);
  if (unlikely((__pyx_nargs < 0))) __PYX_ERR(0, 270, __pyx_L3_error)
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_particle_field,&__pyx_n_s_states,&__pyx_n_s_h,&__pyx_n_s_w,&__pyx_n_s_amplitude,&__pyx_n_s_sigma_x,&__pyx_n_s_sigma_y,0};
  PyObject* values[7] = {0,0,0,0,0,0,0};
    if (__pyx_kwds) {
      Py_ssize_t kw_args;
      switch (__pyx_nargs) {
        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
      switch (__pyx_nargs) {
        case  0:
        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_particle_field)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_states)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, 1); __PYX_ERR(0, 270, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_h)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, 2); __PYX_ERR(0, 270, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_w)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, 3); __PYX_ERR(0, 270, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_amplitude)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, 4); __PYX_ERR(0, 270, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sigma_x)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, 5); __PYX_ERR(0, 270, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sigma_y)) != 0)) {
          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);
          kw_args--;
        }
        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
        else {
          __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, 6); __PYX_ERR(0, 270, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        const Py_ssize_t kwd_pos_args = __pyx_nargs;
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "render_particle_gaussians_with_tracks") < 0)) __PYX_ERR(0, 270, __pyx_L3_error)
      }
    } else if (unlikely(__pyx_nargs != 7)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);
      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);
    }
    __pyx_v_particle_field = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_particle_field.memview)) __PYX_ERR(0, 270, __pyx_L3_error)
    __pyx_v_states = __Pyx_PyObject_to_MemoryviewSlice_dsds_int(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_states.memview)) __PYX_ERR(0, 270, __pyx_L3_error)
    __pyx_v_h = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_h == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
    __pyx_v_w = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_w == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
    __pyx_v_amplitude = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_amplitude == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
    __pyx_v_sigma_x = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_sigma_x == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
    __pyx_v_sigma_y = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_sigma_y == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("render_particle_gaussians_with_tracks", 1, 7, 7, __pyx_nargs); __PYX_ERR(0, 270, __pyx_L3_error)
  goto __pyx_L3_error;
  __pyx_L3_error:;
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_states, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_gaussians_with_tracks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_8render_particle_gaussians_with_tracks(__pyx_self, __pyx_v_particle_field, __pyx_v_states, __pyx_v_h, __pyx_v_w, __pyx_v_amplitude, __pyx_v_sigma_x, __pyx_v_sigma_y);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_states, 1);
  {
    Py_ssize_t __pyx_temp;
    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
    }
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7nanopyx_4core_8generate_23simulate_particle_field_8render_particle_gaussians_with_tracks(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_particle_field, __Pyx_memviewslice __pyx_v_states, int __pyx_v_h, int __pyx_v_w, double __pyx_v_amplitude, double __pyx_v_sigma_x, double __pyx_v_sigma_y) {
  int __pyx_v_n_frames;
  PyObject *__pyx_v_image_particle_field = NULL;
  __Pyx_memviewslice __pyx_v__image_particle_field = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_n_particles;
  __Pyx_memviewslice __pyx_v_xp = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_memviewslice __pyx_v_yp = { 0, 0, { 0 }, { 0 }, { 0 } };
  int __pyx_v_x;
  int __pyx_v_y;
  int __pyx_v_i;
  int __pyx_v_f;
  int __pyx_v_b;
  CYTHON_UNUSED int __pyx_v_b_stop;
  PyObject *__pyx_v_progress_bar = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("render_particle_gaussians_with_tracks", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_28, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_29, 1);
  __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_gaussians_with_tracks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_image_particle_field);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v__image_particle_field, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_xp, 1);
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_yp, 1);
  __Pyx_XDECREF(__pyx_v_progress_bar);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__34 = PyTuple_Pack(20, __pyx_n_s_particle_field, __pyx_n_s_states, __pyx_n_s_h, __pyx_n_s_w, __pyx_n_s_amplitude, __pyx_n_s_sigma_x, __pyx_n_s_sigma_y, __pyx_n_s_n_frames, __pyx_n_s_image_particle_field, __pyx_n_s_image_particle_field_2, __pyx_n_s_n_particles, __pyx_n_s_xp, __pyx_n_s_yp, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_i, __pyx_n_s_f, __pyx_n_s_b, __pyx_n_s_b_stop, __pyx_n_s_progress_bar); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 270, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__34);
  __Pyx_GIVEREF(__pyx_tuple__34);
/* … */
  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_7nanopyx_4core_8generate_23simulate_particle_field_9render_particle_gaussians_with_tracks, 0, __pyx_n_s_render_particle_gaussians_with_t, NULL, __pyx_n_s_nanopyx_core_generate_simulate_p, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_render_particle_gaussians_with_t, __pyx_t_7) < 0) __PYX_ERR(0, 270, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

 271:

+272:     assert particle_field.shape[0] == states.shape[0]

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_1 = ((__pyx_v_particle_field.shape[0]) == (__pyx_v_states.shape[0]));
    if (unlikely(!__pyx_t_1)) {
      __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
      __PYX_ERR(0, 272, __pyx_L1_error)
    }
  }
  #else
  if ((1)); else __PYX_ERR(0, 272, __pyx_L1_error)
  #endif

 273:

+274:     cdef int n_frames = states.shape[1]

  __pyx_v_n_frames = (__pyx_v_states.shape[1]);

 275:

+276:     image_particle_field = np.zeros((n_frames, h, w), dtype=np.float32)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_frames); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_h); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_w); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_4);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 276, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 276, __pyx_L1_error);
  __pyx_t_2 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error);
  __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_image_particle_field = __pyx_t_2;
  __pyx_t_2 = 0;

+277:     cdef float[:,:,:] _image_particle_field = image_particle_field

  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_image_particle_field, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 277, __pyx_L1_error)
  __pyx_v__image_particle_field = __pyx_t_7;
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;

 278:

+279:     cdef int n_particles = particle_field.shape[0]

  __pyx_v_n_particles = (__pyx_v_particle_field.shape[0]);

+280:     cdef float[:] xp = particle_field[:, 0]

  __pyx_t_8.data = __pyx_v_particle_field.data;
  __pyx_t_8.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_8.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_8.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 0;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_8.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_xp = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

+281:     cdef float[:] yp = particle_field[:, 1]

  __pyx_t_8.data = __pyx_v_particle_field.data;
  __pyx_t_8.memview = __pyx_v_particle_field.memview;
  __PYX_INC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.shape[0] = __pyx_v_particle_field.shape[0];
__pyx_t_8.strides[0] = __pyx_v_particle_field.strides[0];
    __pyx_t_8.suboffsets[0] = -1;

{
    Py_ssize_t __pyx_tmp_idx = 1;
    Py_ssize_t __pyx_tmp_stride = __pyx_v_particle_field.strides[1];
        __pyx_t_8.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_v_yp = __pyx_t_8;
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;

 282:

 283:     cdef int x, y, i, f, b, b_stop

 284:

 285:     # break into 100 particles at a time

+286:     with tqdm(total=n_particles, desc="Rendering particles", unit="particles") as progress_bar:

  /*with:*/ {
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_tqdm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_total, __pyx_t_5) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_desc, __pyx_kp_u_Rendering_particles) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
    if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_unit, __pyx_n_u_particles) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_5, __pyx_n_s_exit); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_t_5, __pyx_n_s_enter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L3_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = NULL;
    __pyx_t_10 = 0;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_10 = 1;
      }
    }
    #endif
    {
      PyObject *__pyx_callargs[1] = {__pyx_t_3, };
      __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_10, 0+__pyx_t_10);
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L3_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __pyx_t_2 = __pyx_t_6;
    __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    /*try:*/ {
      {
        /*try:*/ {
          __pyx_v_progress_bar = __pyx_t_2;
          __pyx_t_2 = 0;
/* … */
        }
        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        goto __pyx_L12_try_end;
        __pyx_L7_error:;
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __PYX_XCLEAR_MEMVIEW(&__pyx_t_28, 1);
        __pyx_t_28.memview = NULL; __pyx_t_28.data = NULL;
        __PYX_XCLEAR_MEMVIEW(&__pyx_t_29, 1);
        __pyx_t_29.memview = NULL; __pyx_t_29.data = NULL;
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 1);
        __pyx_t_7.memview = NULL; __pyx_t_7.data = NULL;
        __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1);
        __pyx_t_8.memview = NULL; __pyx_t_8.data = NULL;
        /*except:*/ {
          __Pyx_AddTraceback("nanopyx.core.generate.simulate_particle_field.render_particle_gaussians_with_tracks", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 286, __pyx_L9_except_error)
          __Pyx_XGOTREF(__pyx_t_2);
          __Pyx_XGOTREF(__pyx_t_5);
          __Pyx_XGOTREF(__pyx_t_6);
          __pyx_t_3 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_30 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_3, NULL);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_30)) __PYX_ERR(0, 286, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_30);
          __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_30);
          __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0;
          if (__pyx_t_1 < 0) __PYX_ERR(0, 286, __pyx_L9_except_error)
          __pyx_t_23 = (!__pyx_t_1);
          if (unlikely(__pyx_t_23)) {
            __Pyx_GIVEREF(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_5);
            __Pyx_XGIVEREF(__pyx_t_6);
            __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_5, __pyx_t_6);
            __pyx_t_2 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; 
            __PYX_ERR(0, 286, __pyx_L9_except_error)
          }
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          goto __pyx_L8_exception_handled;
        }
        __pyx_L9_except_error:;
        __Pyx_XGIVEREF(__pyx_t_11);
        __Pyx_XGIVEREF(__pyx_t_12);
        __Pyx_XGIVEREF(__pyx_t_13);
        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
        goto __pyx_L1_error;
        __pyx_L8_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_11);
        __Pyx_XGIVEREF(__pyx_t_12);
        __Pyx_XGIVEREF(__pyx_t_13);
        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
        __pyx_L12_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_9) {
          __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__14, NULL);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 286, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        }
        goto __pyx_L6;
      }
      __pyx_L6:;
    }
    goto __pyx_L35;
    __pyx_L3_error:;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    goto __pyx_L1_error;
    __pyx_L35:;
  }

+287:         for b in range(0, n_particles, 100):

          __pyx_t_10 = __pyx_v_n_particles;
          __pyx_t_14 = __pyx_t_10;
          for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=0x64) {
            __pyx_v_b = __pyx_t_15;

+288:             with nogil:

            {
                #ifdef WITH_THREAD
                PyThreadState *_save;
                _save = NULL;
                Py_UNBLOCK_THREADS
                __Pyx_FastGIL_Remember();
                #endif
                /*try:*/ {
/* … */
                /*finally:*/ {
                  /*normal exit:*/{
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L19;
                  }
                  __pyx_L18_error: {
                    #ifdef WITH_THREAD
                    __Pyx_FastGIL_Forget();
                    Py_BLOCK_THREADS
                    #endif
                    goto __pyx_L7_error;
                  }
                  __pyx_L19:;
                }
            }

+289:                 b_stop = min(b + 100, n_particles)

                  __pyx_t_16 = __pyx_v_n_particles;
                  __pyx_t_17 = (__pyx_v_b + 0x64);
                  __pyx_t_1 = (__pyx_t_16 < __pyx_t_17);
                  if (__pyx_t_1) {
                    __pyx_t_18 = __pyx_t_16;
                  } else {
                    __pyx_t_18 = __pyx_t_17;
                  }
                  __pyx_v_b_stop = __pyx_t_18;

+290:                 for i in prange(b, b_stop):

                  __pyx_t_16 = __pyx_v_b;
                  __pyx_t_19 = __pyx_v_b_stop;
                  {
                      #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                          #undef likely
                          #undef unlikely
                          #define likely(x)   (x)
                          #define unlikely(x) (x)
                      #endif
                      __pyx_t_21 = (__pyx_t_19 - __pyx_t_16 + 1 - 1/abs(1)) / 1;
                      if (__pyx_t_21 > 0)
                      {
                          #ifdef _OPENMP
                          #pragma omp parallel
                          #endif /* _OPENMP */
                          {
                              #ifdef _OPENMP
                              #pragma omp for lastprivate(__pyx_v_f) firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) lastprivate(__pyx_v_x) lastprivate(__pyx_v_y)
                              #endif /* _OPENMP */
                              for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_21; __pyx_t_20++){
                                  {
                                      __pyx_v_i = (int)(__pyx_t_16 + 1 * __pyx_t_20);
                                      /* Initialize private variables to invalid values */
                                      __pyx_v_f = ((int)0xbad0bad0);
                                      __pyx_v_x = ((int)0xbad0bad0);
                                      __pyx_v_y = ((int)0xbad0bad0);

+291:                     x = int(xp[i])

                                      __pyx_t_22 = __pyx_v_i;
                                      __pyx_v_x = ((int)(*((float *) ( /* dim=0 */ (__pyx_v_xp.data + __pyx_t_22 * __pyx_v_xp.strides[0]) ))));

+292:                     y = int(yp[i])

                                      __pyx_t_22 = __pyx_v_i;
                                      __pyx_v_y = ((int)(*((float *) ( /* dim=0 */ (__pyx_v_yp.data + __pyx_t_22 * __pyx_v_yp.strides[0]) ))));

+293:                     if 0 <= x < w or 0 <= y < h:

                                      __pyx_t_23 = (0 <= __pyx_v_x);
                                      if (__pyx_t_23) {
                                        __pyx_t_23 = (__pyx_v_x < __pyx_v_w);
                                      }
                                      if (!__pyx_t_23) {
                                      } else {
                                        __pyx_t_1 = __pyx_t_23;
                                        goto __pyx_L25_bool_binop_done;
                                      }
                                      __pyx_t_23 = (0 <= __pyx_v_y);
                                      if (__pyx_t_23) {
                                        __pyx_t_23 = (__pyx_v_y < __pyx_v_h);
                                      }
                                      __pyx_t_1 = __pyx_t_23;
                                      __pyx_L25_bool_binop_done:;
                                      if (__pyx_t_1) {
/* … */
                                      }
                                      goto __pyx_L31;
                                      __pyx_L22_error:;
                                      {
                                          #ifdef WITH_THREAD
                                          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                                          #endif
                                          #ifdef _OPENMP
                                          #pragma omp flush(__pyx_parallel_exc_type)
                                          #endif /* _OPENMP */
                                          if (!__pyx_parallel_exc_type) {
                                            __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
                                            __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
                                            __Pyx_GOTREF(__pyx_parallel_exc_type);
                                          }
                                          #ifdef WITH_THREAD
                                          __Pyx_PyGILState_Release(__pyx_gilstate_save);
                                          #endif
                                      }
                                      __pyx_parallel_why = 4;
                                      goto __pyx_L30;
                                      __pyx_L30:;
                                      #ifdef _OPENMP
                                      #pragma omp critical(__pyx_parallel_lastprivates6)
                                      #endif /* _OPENMP */
                                      {
                                          __pyx_parallel_temp0 = __pyx_v_f;
                                          __pyx_parallel_temp1 = __pyx_v_i;
                                          __pyx_parallel_temp2 = __pyx_v_x;
                                          __pyx_parallel_temp3 = __pyx_v_y;
                                      }
                                      __pyx_L31:;
                                      #ifdef _OPENMP
                                      #pragma omp flush(__pyx_parallel_why)
                                      #endif /* _OPENMP */
                                  }
                              }
                              #ifdef _OPENMP
                              Py_END_ALLOW_THREADS
                              #else
{
#ifdef WITH_THREAD
                              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                              #endif
                              #endif /* _OPENMP */
                              /* Clean up any temporaries */
                              __PYX_XCLEAR_MEMVIEW(&__pyx_t_28, 0);
                              __pyx_t_28.memview = NULL; __pyx_t_28.data = NULL;
                              __PYX_XCLEAR_MEMVIEW(&__pyx_t_29, 0);
                              __pyx_t_29.memview = NULL; __pyx_t_29.data = NULL;
                              #ifdef WITH_THREAD
                              __Pyx_PyGILState_Release(__pyx_gilstate_save);
                              #endif
                              #ifndef _OPENMP
}
#endif /* _OPENMP */
                          }
                      }
                      if (__pyx_parallel_exc_type) {
                        /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
                        __pyx_parallel_why = 4;
                      }
                      if (__pyx_parallel_why) {
                        __pyx_v_f = __pyx_parallel_temp0;
                        __pyx_v_i = __pyx_parallel_temp1;
                        __pyx_v_x = __pyx_parallel_temp2;
                        __pyx_v_y = __pyx_parallel_temp3;
                        switch (__pyx_parallel_why) {
                              case 4:
                          {
                              #ifdef WITH_THREAD
                              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
                              #endif
                              __Pyx_GIVEREF(__pyx_parallel_exc_type);
                              __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
                              __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
                              #ifdef WITH_THREAD
                              __Pyx_PyGILState_Release(__pyx_gilstate_save);
                              #endif
                          }
                          goto __pyx_L18_error;
                        }
                      }
                  }
                  #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                      #undef likely
                      #undef unlikely
                      #define likely(x)   __builtin_expect(!!(x), 1)
                      #define unlikely(x) __builtin_expect(!!(x), 0)
                  #endif
                }

+294:                         for f in range(n_frames):

                                        __pyx_t_24 = __pyx_v_n_frames;
                                        __pyx_t_25 = __pyx_t_24;
                                        for (__pyx_t_26 = 0; __pyx_t_26 < __pyx_t_25; __pyx_t_26+=1) {
                                          __pyx_v_f = __pyx_t_26;

+295:                             if states[i, f] == 1:

                                          __pyx_t_22 = __pyx_v_i;
                                          __pyx_t_27 = __pyx_v_f;
                                          __pyx_t_1 = ((*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_states.data + __pyx_t_22 * __pyx_v_states.strides[0]) ) + __pyx_t_27 * __pyx_v_states.strides[1]) ))) == 1);
                                          if (__pyx_t_1) {
/* … */
                                          }
                                        }

+296:                                 _render_erf_gaussian(_image_particle_field[f], x, y, amplitude, sigma_x, sigma_y)

                                            __pyx_t_28.data = __pyx_v__image_particle_field.data;
                                            __pyx_t_28.memview = __pyx_v__image_particle_field.memview;
                                            __PYX_INC_MEMVIEW(&__pyx_t_28, 0);
                                            {
    Py_ssize_t __pyx_tmp_idx = __pyx_v_f;
    Py_ssize_t __pyx_tmp_stride = __pyx_v__image_particle_field.strides[0];
        __pyx_t_28.data += __pyx_tmp_idx * __pyx_tmp_stride;
}

__pyx_t_28.shape[0] = __pyx_v__image_particle_field.shape[1];
__pyx_t_28.strides[0] = __pyx_v__image_particle_field.strides[1];
    __pyx_t_28.suboffsets[0] = -1;

__pyx_t_28.shape[1] = __pyx_v__image_particle_field.shape[2];
__pyx_t_28.strides[1] = __pyx_v__image_particle_field.strides[2];
    __pyx_t_28.suboffsets[1] = -1;

__pyx_t_29 = __pyx_f_7nanopyx_4core_8generate_19noise_add_gaussians__render_erf_gaussian(__pyx_t_28, __pyx_v_x, __pyx_v_y, __pyx_v_amplitude, __pyx_v_sigma_x, __pyx_v_sigma_y); if (unlikely(!__pyx_t_29.memview)) __PYX_ERR(0, 296, __pyx_L22_error)
                                            __PYX_XCLEAR_MEMVIEW(&__pyx_t_28, 0);
                                            __pyx_t_28.memview = NULL; __pyx_t_28.data = NULL;
                                            __PYX_XCLEAR_MEMVIEW(&__pyx_t_29, 0);
                                            __pyx_t_29.memview = NULL; __pyx_t_29.data = NULL;

+297:             progress_bar.update(100)

            __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_progress_bar, __pyx_n_s_update); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 297, __pyx_L7_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_6 = NULL;
            __pyx_t_21 = 0;
            #if CYTHON_UNPACK_METHODS
            if (likely(PyMethod_Check(__pyx_t_5))) {
              __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
              if (likely(__pyx_t_6)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
                __Pyx_INCREF(__pyx_t_6);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_5, function);
                __pyx_t_21 = 1;
              }
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_int_100};
              __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_21, 1+__pyx_t_21);
              __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
              if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L7_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            }
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          }

 298:

+299:     return image_particle_field

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_image_particle_field);
  __pyx_r = __pyx_v_image_particle_field;
  goto __pyx_L0;